import java.util.Scanner;

public class RobotWalk {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int m=sc.nextInt();
        int k=sc.nextInt();
        int p=sc.nextInt();
        int ret=walk(n,m,k,p);
        System.out.println(ret);
        System.out.println("==========");
        int sun=walk1(n,m,k,p);
        System.out.println(sun);
    }

    private static int walk(int n, int m, int k, int p) {
        if(n<2 || k<1 || m<1 || m>n || p<1 || p>n)
        {
            return 0;
        }
        return way(n,m,k,p);
    }

    //n 表示一共有多少个数
    //m 表示当前位置
    //k 表示还可以走多少步
    //p 表示目的位置
    private static int way(int n, int m, int k, int p) {

        if (k==0)
        {
            return m==p?1:0;
        }
        if(m==1)
        {
            way(n,2,k-1,p);
        }
        if(m==n)
        {
            way(n,n-1,k-1,p);
        }
        return way(n,m+1,k-1,p)+way(n,m-1,k-1,p);
    }


    private static int walk1(int n, int m, int k, int p) {
        if(n<2 || k<1 || m<1 || m>n || p<1 || p>n)
        {
            return 0;
        }
        int[][] dp=new int[n+1][k+1];
        for(int row=0;row<=n;row++)
        {
            for(int col=0;col<=k;col++)
            {
                dp[row][col]=-1;
            }
        }
        return way1(n,m,k,p,dp);
    }


//(2).第二种算法
/*
基于动态规划的暴力递归解法
所有的动态规划都来自一个暴力递归
 */
    //n 表示一共有多少个数
    //m 表示当前位置
    //k 表示还可以走多少步
    //p 表示目的位置
    private static int way1(int n, int m, int k, int p,int[][] dp) {
        if(dp[m][k]!=-1)
        {
            return dp[m][k];
        }
        if (k==0)
        {
            dp[m][k]=m==p?1:0;
            return dp[m][k];
        }
        if(m==1)
        {
            dp[m][k]=way(n,2,k-1,p);
            return dp[m][k];
        }
        if(m==n)
        {
            dp[m][k]=way(n,n-1,k-1,p);
            return dp[m][k];
        }
        dp[m][k]=way(n,m+1,k-1,p)+way(n,m-1,k-1,p);
        return dp[m][k];
    }
}
